package br.edu.ufcg.dsc.compiladores.serializer;

import br.edu.ufcg.dsc.compiladores.pascal.ConstFromDigitSequence;
import br.edu.ufcg.dsc.compiladores.pascal.ConstFromId;
import br.edu.ufcg.dsc.compiladores.pascal.ConstFromReal;
import br.edu.ufcg.dsc.compiladores.pascal.ConstFromString;
import br.edu.ufcg.dsc.compiladores.pascal.DIGIT_SEQUENCE;
import br.edu.ufcg.dsc.compiladores.pascal.FieldListClass;
import br.edu.ufcg.dsc.compiladores.pascal.FunctionDeclarationWithHeading;
import br.edu.ufcg.dsc.compiladores.pascal.Model;
import br.edu.ufcg.dsc.compiladores.pascal.PascalPackage;
import br.edu.ufcg.dsc.compiladores.pascal.ProceduresAndFunctionDeclaration;
import br.edu.ufcg.dsc.compiladores.pascal.REAL_NUMBER;
import br.edu.ufcg.dsc.compiladores.pascal.VariableLClass;
import br.edu.ufcg.dsc.compiladores.pascal.actual_parameter_list;
import br.edu.ufcg.dsc.compiladores.pascal.array_type;
import br.edu.ufcg.dsc.compiladores.pascal.assignment_statement;
import br.edu.ufcg.dsc.compiladores.pascal.block;
import br.edu.ufcg.dsc.compiladores.pascal.case_label_list;
import br.edu.ufcg.dsc.compiladores.pascal.case_limb;
import br.edu.ufcg.dsc.compiladores.pascal.case_statement;
import br.edu.ufcg.dsc.compiladores.pascal.constant_definition;
import br.edu.ufcg.dsc.compiladores.pascal.constant_definition_part;
import br.edu.ufcg.dsc.compiladores.pascal.declaration_part;
import br.edu.ufcg.dsc.compiladores.pascal.element_list;
import br.edu.ufcg.dsc.compiladores.pascal.expression;
import br.edu.ufcg.dsc.compiladores.pascal.expression_list;
import br.edu.ufcg.dsc.compiladores.pascal.fixed_part;
import br.edu.ufcg.dsc.compiladores.pascal.for_statement;
import br.edu.ufcg.dsc.compiladores.pascal.formal_parameter_list;
import br.edu.ufcg.dsc.compiladores.pascal.function_body;
import br.edu.ufcg.dsc.compiladores.pascal.function_declaration;
import br.edu.ufcg.dsc.compiladores.pascal.function_designator;
import br.edu.ufcg.dsc.compiladores.pascal.function_heading;
import br.edu.ufcg.dsc.compiladores.pascal.function_identification;
import br.edu.ufcg.dsc.compiladores.pascal.function_identifier;
import br.edu.ufcg.dsc.compiladores.pascal.function_parameter_section;
import br.edu.ufcg.dsc.compiladores.pascal.goto_statement;
import br.edu.ufcg.dsc.compiladores.pascal.identifier_list;
import br.edu.ufcg.dsc.compiladores.pascal.if_statement;
import br.edu.ufcg.dsc.compiladores.pascal.label_declaration_part;
import br.edu.ufcg.dsc.compiladores.pascal.lower_bound;
import br.edu.ufcg.dsc.compiladores.pascal.packed_conformant_array_schema;
import br.edu.ufcg.dsc.compiladores.pascal.pointer_type;
import br.edu.ufcg.dsc.compiladores.pascal.procedure_body;
import br.edu.ufcg.dsc.compiladores.pascal.procedure_declaration;
import br.edu.ufcg.dsc.compiladores.pascal.procedure_heading;
import br.edu.ufcg.dsc.compiladores.pascal.procedure_identification;
import br.edu.ufcg.dsc.compiladores.pascal.procedure_identifier;
import br.edu.ufcg.dsc.compiladores.pascal.procedure_parameter_section;
import br.edu.ufcg.dsc.compiladores.pascal.procedure_statement;
import br.edu.ufcg.dsc.compiladores.pascal.program;
import br.edu.ufcg.dsc.compiladores.pascal.program_heading;
import br.edu.ufcg.dsc.compiladores.pascal.record_section;
import br.edu.ufcg.dsc.compiladores.pascal.repeat_statement;
import br.edu.ufcg.dsc.compiladores.pascal.simple_expression;
import br.edu.ufcg.dsc.compiladores.pascal.statement;
import br.edu.ufcg.dsc.compiladores.pascal.statement_sequence;
import br.edu.ufcg.dsc.compiladores.pascal.structured_type;
import br.edu.ufcg.dsc.compiladores.pascal.subrange_type;
import br.edu.ufcg.dsc.compiladores.pascal.term;
import br.edu.ufcg.dsc.compiladores.pascal.type_definition;
import br.edu.ufcg.dsc.compiladores.pascal.type_definition_part;
import br.edu.ufcg.dsc.compiladores.pascal.type_identifier;
import br.edu.ufcg.dsc.compiladores.pascal.unpacked_conformant_array_schema;
import br.edu.ufcg.dsc.compiladores.pascal.upper_bound;
import br.edu.ufcg.dsc.compiladores.pascal.value_parameter_section;
import br.edu.ufcg.dsc.compiladores.pascal.variable;
import br.edu.ufcg.dsc.compiladores.pascal.variable_declaration;
import br.edu.ufcg.dsc.compiladores.pascal.variable_declaration_part;
import br.edu.ufcg.dsc.compiladores.pascal.variable_identifier;
import br.edu.ufcg.dsc.compiladores.pascal.variable_parameter_section;
import br.edu.ufcg.dsc.compiladores.pascal.variant;
import br.edu.ufcg.dsc.compiladores.pascal.variant_part;
import br.edu.ufcg.dsc.compiladores.pascal.while_statement;
import br.edu.ufcg.dsc.compiladores.pascal.with_statement;
import br.edu.ufcg.dsc.compiladores.services.PascalGrammarAccess;
import com.google.inject.Inject;
import com.google.inject.Provider;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.xtext.serializer.acceptor.ISemanticSequenceAcceptor;
import org.eclipse.xtext.serializer.acceptor.SequenceFeeder;
import org.eclipse.xtext.serializer.diagnostic.ISemanticSequencerDiagnosticProvider;
import org.eclipse.xtext.serializer.diagnostic.ISerializationDiagnostic.Acceptor;
import org.eclipse.xtext.serializer.sequencer.AbstractDelegatingSemanticSequencer;
import org.eclipse.xtext.serializer.sequencer.GenericSequencer;
import org.eclipse.xtext.serializer.sequencer.ISemanticNodeProvider.INodesForEObjectProvider;
import org.eclipse.xtext.serializer.sequencer.ISemanticSequencer;
import org.eclipse.xtext.serializer.sequencer.ITransientValueService;
import org.eclipse.xtext.serializer.sequencer.ITransientValueService.ValueTransient;

@SuppressWarnings("all")
public class PascalSemanticSequencer extends AbstractDelegatingSemanticSequencer {

	@Inject
	private PascalGrammarAccess grammarAccess;
	
	public void createSequence(EObject context, EObject semanticObject) {
		if(semanticObject.eClass().getEPackage() == PascalPackage.eINSTANCE) switch(semanticObject.eClass().getClassifierID()) {
			case PascalPackage.CONST_FROM_DIGIT_SEQUENCE:
				if(context == grammarAccess.getConstantRule()) {
					sequence_constant(context, (ConstFromDigitSequence) semanticObject); 
					return; 
				}
				else break;
			case PascalPackage.CONST_FROM_ID:
				if(context == grammarAccess.getConstantRule()) {
					sequence_constant(context, (ConstFromId) semanticObject); 
					return; 
				}
				else break;
			case PascalPackage.CONST_FROM_REAL:
				if(context == grammarAccess.getConstantRule()) {
					sequence_constant(context, (ConstFromReal) semanticObject); 
					return; 
				}
				else break;
			case PascalPackage.CONST_FROM_STRING:
				if(context == grammarAccess.getConstantRule()) {
					sequence_constant(context, (ConstFromString) semanticObject); 
					return; 
				}
				else break;
			case PascalPackage.DIGIT_SEQUENCE:
				if(context == grammarAccess.getDIGIT_SEQUENCERule() ||
				   context == grammarAccess.getLABELRule() ||
				   context == grammarAccess.getFactorRule() ||
				   context == grammarAccess.getScale_factorRule()) {
					sequence_DIGIT_SEQUENCE(context, (DIGIT_SEQUENCE) semanticObject); 
					return; 
				}
				else break;
			case PascalPackage.FIELD_LIST_CLASS:
				if(context == grammarAccess.getField_listRule() ||
				   context == grammarAccess.getRecord_typeRule() ||
				   context == grammarAccess.getUnpacked_structured_typeRule()) {
					sequence_field_list(context, (FieldListClass) semanticObject); 
					return; 
				}
				else break;
			case PascalPackage.FUNCTION_DECLARATION_WITH_HEADING:
				if(context == grammarAccess.getFunction_declarationRule()) {
					sequence_function_declaration(context, (FunctionDeclarationWithHeading) semanticObject); 
					return; 
				}
				else break;
			case PascalPackage.MODEL:
				if(context == grammarAccess.getModelRule()) {
					sequence_Model(context, (Model) semanticObject); 
					return; 
				}
				else break;
			case PascalPackage.PROCEDURES_AND_FUNCTION_DECLARATION:
				if(context == grammarAccess.getProcedure_and_function_declaration_partRule()) {
					sequence_procedure_and_function_declaration_part(context, (ProceduresAndFunctionDeclaration) semanticObject); 
					return; 
				}
				else break;
			case PascalPackage.REAL_NUMBER:
				if(context == grammarAccess.getREAL_NUMBERRule() ||
				   context == grammarAccess.getFactorRule()) {
					sequence_REAL_NUMBER(context, (REAL_NUMBER) semanticObject); 
					return; 
				}
				else break;
			case PascalPackage.VARIABLE_LCLASS:
				if(context == grammarAccess.getVariable_lRule()) {
					sequence_variable_l(context, (VariableLClass) semanticObject); 
					return; 
				}
				else break;
			case PascalPackage.ACTUAL_PARAMETER_LIST:
				if(context == grammarAccess.getActual_parameter_listRule()) {
					sequence_actual_parameter_list(context, (actual_parameter_list) semanticObject); 
					return; 
				}
				else break;
			case PascalPackage.ARRAY_TYPE:
				if(context == grammarAccess.getArray_typeRule() ||
				   context == grammarAccess.getUnpacked_structured_typeRule()) {
					sequence_array_type(context, (array_type) semanticObject); 
					return; 
				}
				else break;
			case PascalPackage.ASSIGNMENT_STATEMENT:
				if(context == grammarAccess.getAssignment_statementRule() ||
				   context == grammarAccess.getSimple_statementRule()) {
					sequence_assignment_statement(context, (assignment_statement) semanticObject); 
					return; 
				}
				else break;
			case PascalPackage.BLOCK:
				if(context == grammarAccess.getBlockRule()) {
					sequence_block(context, (block) semanticObject); 
					return; 
				}
				else break;
			case PascalPackage.CASE_LABEL_LIST:
				if(context == grammarAccess.getCase_label_listRule()) {
					sequence_case_label_list(context, (case_label_list) semanticObject); 
					return; 
				}
				else break;
			case PascalPackage.CASE_LIMB:
				if(context == grammarAccess.getCase_limbRule()) {
					sequence_case_limb(context, (case_limb) semanticObject); 
					return; 
				}
				else break;
			case PascalPackage.CASE_STATEMENT:
				if(context == grammarAccess.getCase_statementRule() ||
				   context == grammarAccess.getConditional_statementRule() ||
				   context == grammarAccess.getStructured_statementRule()) {
					sequence_case_statement(context, (case_statement) semanticObject); 
					return; 
				}
				else break;
			case PascalPackage.CONSTANT_DEFINITION:
				if(context == grammarAccess.getConstant_definitionRule()) {
					sequence_constant_definition(context, (constant_definition) semanticObject); 
					return; 
				}
				else break;
			case PascalPackage.CONSTANT_DEFINITION_PART:
				if(context == grammarAccess.getConstant_definition_partRule()) {
					sequence_constant_definition_part(context, (constant_definition_part) semanticObject); 
					return; 
				}
				else break;
			case PascalPackage.DECLARATION_PART:
				if(context == grammarAccess.getDeclaration_partRule()) {
					sequence_declaration_part(context, (declaration_part) semanticObject); 
					return; 
				}
				else break;
			case PascalPackage.ELEMENT_LIST:
				if(context == grammarAccess.getElement_listRule() ||
				   context == grammarAccess.getFactorRule() ||
				   context == grammarAccess.getSetRule()) {
					sequence_element_list(context, (element_list) semanticObject); 
					return; 
				}
				else break;
			case PascalPackage.EXPRESSION:
				if(context == grammarAccess.getActual_parameterRule() ||
				   context == grammarAccess.getActual_valueRule() ||
				   context == grammarAccess.getExpressionRule() ||
				   context == grammarAccess.getFactorRule() ||
				   context == grammarAccess.getFinal_expressionRule() ||
				   context == grammarAccess.getInitial_expressionRule()) {
					sequence_expression(context, (expression) semanticObject); 
					return; 
				}
				else break;
			case PascalPackage.EXPRESSION_LIST:
				if(context == grammarAccess.getExpression_listRule()) {
					sequence_expression_list(context, (expression_list) semanticObject); 
					return; 
				}
				else break;
			case PascalPackage.FIXED_PART:
				if(context == grammarAccess.getFixed_partRule()) {
					sequence_fixed_part(context, (fixed_part) semanticObject); 
					return; 
				}
				else break;
			case PascalPackage.FOR_STATEMENT:
				if(context == grammarAccess.getFor_statementRule() ||
				   context == grammarAccess.getRepetitive_statementRule() ||
				   context == grammarAccess.getStructured_statementRule()) {
					sequence_for_statement(context, (for_statement) semanticObject); 
					return; 
				}
				else break;
			case PascalPackage.FORMAL_PARAMETER_LIST:
				if(context == grammarAccess.getFormal_parameter_listRule()) {
					sequence_formal_parameter_list(context, (formal_parameter_list) semanticObject); 
					return; 
				}
				else break;
			case PascalPackage.FUNCTION_BODY:
				if(context == grammarAccess.getFunction_bodyRule()) {
					sequence_function_body(context, (function_body) semanticObject); 
					return; 
				}
				else break;
			case PascalPackage.FUNCTION_DECLARATION:
				if(context == grammarAccess.getFunction_declarationRule()) {
					sequence_function_declaration(context, (function_declaration) semanticObject); 
					return; 
				}
				else break;
			case PascalPackage.FUNCTION_DESIGNATOR:
				if(context == grammarAccess.getFactorRule() ||
				   context == grammarAccess.getFunction_designatorRule()) {
					sequence_function_designator(context, (function_designator) semanticObject); 
					return; 
				}
				else break;
			case PascalPackage.FUNCTION_HEADING:
				if(context == grammarAccess.getFunction_headingRule()) {
					sequence_function_heading(context, (function_heading) semanticObject); 
					return; 
				}
				else break;
			case PascalPackage.FUNCTION_IDENTIFICATION:
				if(context == grammarAccess.getFunction_identificationRule()) {
					sequence_function_identification(context, (function_identification) semanticObject); 
					return; 
				}
				else break;
			case PascalPackage.FUNCTION_IDENTIFIER:
				if(context == grammarAccess.getFunction_identifierRule()) {
					sequence_function_identifier(context, (function_identifier) semanticObject); 
					return; 
				}
				else break;
			case PascalPackage.FUNCTION_PARAMETER_SECTION:
				if(context == grammarAccess.getFormal_parameter_sectionRule() ||
				   context == grammarAccess.getFunction_parameter_sectionRule()) {
					sequence_function_parameter_section(context, (function_parameter_section) semanticObject); 
					return; 
				}
				else break;
			case PascalPackage.GOTO_STATEMENT:
				if(context == grammarAccess.getGoto_statementRule() ||
				   context == grammarAccess.getSimple_statementRule()) {
					sequence_goto_statement(context, (goto_statement) semanticObject); 
					return; 
				}
				else break;
			case PascalPackage.IDENTIFIER_LIST:
				if(context == grammarAccess.getBase_typeRule() ||
				   context == grammarAccess.getElement_typeRule() ||
				   context == grammarAccess.getEnumerated_typeRule() ||
				   context == grammarAccess.getFile_component_typeRule() ||
				   context == grammarAccess.getFile_typeRule() ||
				   context == grammarAccess.getIdentifier_listRule() ||
				   context == grammarAccess.getIndex_typeRule() ||
				   context == grammarAccess.getSet_typeRule() ||
				   context == grammarAccess.getSimple_typeRule() ||
				   context == grammarAccess.getTypeRule() ||
				   context == grammarAccess.getUnpacked_structured_typeRule()) {
					sequence_identifier_list(context, (identifier_list) semanticObject); 
					return; 
				}
				else break;
			case PascalPackage.IF_STATEMENT:
				if(context == grammarAccess.getConditional_statementRule() ||
				   context == grammarAccess.getIf_statementRule() ||
				   context == grammarAccess.getStructured_statementRule()) {
					sequence_if_statement(context, (if_statement) semanticObject); 
					return; 
				}
				else break;
			case PascalPackage.LABEL_DECLARATION_PART:
				if(context == grammarAccess.getLabel_declaration_partRule()) {
					sequence_label_declaration_part(context, (label_declaration_part) semanticObject); 
					return; 
				}
				else break;
			case PascalPackage.LOWER_BOUND:
				if(context == grammarAccess.getLower_boundRule()) {
					sequence_lower_bound(context, (lower_bound) semanticObject); 
					return; 
				}
				else break;
			case PascalPackage.PACKED_CONFORMANT_ARRAY_SCHEMA:
				if(context == grammarAccess.getConformant_array_schemaRule() ||
				   context == grammarAccess.getPacked_conformant_array_schemaRule() ||
				   context == grammarAccess.getParameter_typeRule()) {
					sequence_packed_conformant_array_schema(context, (packed_conformant_array_schema) semanticObject); 
					return; 
				}
				else break;
			case PascalPackage.POINTER_TYPE:
				if(context == grammarAccess.getBase_typeRule() ||
				   context == grammarAccess.getElement_typeRule() ||
				   context == grammarAccess.getFile_component_typeRule() ||
				   context == grammarAccess.getFile_typeRule() ||
				   context == grammarAccess.getPointer_typeRule() ||
				   context == grammarAccess.getSet_typeRule() ||
				   context == grammarAccess.getTypeRule() ||
				   context == grammarAccess.getUnpacked_structured_typeRule()) {
					sequence_pointer_type(context, (pointer_type) semanticObject); 
					return; 
				}
				else break;
			case PascalPackage.PROCEDURE_BODY:
				if(context == grammarAccess.getProcedure_bodyRule()) {
					sequence_procedure_body(context, (procedure_body) semanticObject); 
					return; 
				}
				else break;
			case PascalPackage.PROCEDURE_DECLARATION:
				if(context == grammarAccess.getProcedure_declarationRule()) {
					sequence_procedure_declaration(context, (procedure_declaration) semanticObject); 
					return; 
				}
				else break;
			case PascalPackage.PROCEDURE_HEADING:
				if(context == grammarAccess.getProcedure_headingRule()) {
					sequence_procedure_heading(context, (procedure_heading) semanticObject); 
					return; 
				}
				else break;
			case PascalPackage.PROCEDURE_IDENTIFICATION:
				if(context == grammarAccess.getProcedure_identificationRule()) {
					sequence_procedure_identification(context, (procedure_identification) semanticObject); 
					return; 
				}
				else break;
			case PascalPackage.PROCEDURE_IDENTIFIER:
				if(context == grammarAccess.getProcedure_identifierRule()) {
					sequence_procedure_identifier(context, (procedure_identifier) semanticObject); 
					return; 
				}
				else break;
			case PascalPackage.PROCEDURE_PARAMETER_SECTION:
				if(context == grammarAccess.getFormal_parameter_sectionRule() ||
				   context == grammarAccess.getProcedure_parameter_sectionRule()) {
					sequence_procedure_parameter_section(context, (procedure_parameter_section) semanticObject); 
					return; 
				}
				else break;
			case PascalPackage.PROCEDURE_STATEMENT:
				if(context == grammarAccess.getProcedure_statementRule() ||
				   context == grammarAccess.getSimple_statementRule()) {
					sequence_procedure_statement(context, (procedure_statement) semanticObject); 
					return; 
				}
				else break;
			case PascalPackage.PROGRAM:
				if(context == grammarAccess.getProgramRule()) {
					sequence_program(context, (program) semanticObject); 
					return; 
				}
				else break;
			case PascalPackage.PROGRAM_HEADING:
				if(context == grammarAccess.getProgram_headingRule()) {
					sequence_program_heading(context, (program_heading) semanticObject); 
					return; 
				}
				else break;
			case PascalPackage.RECORD_SECTION:
				if(context == grammarAccess.getRecord_sectionRule()) {
					sequence_record_section(context, (record_section) semanticObject); 
					return; 
				}
				else break;
			case PascalPackage.REPEAT_STATEMENT:
				if(context == grammarAccess.getRepeat_statementRule() ||
				   context == grammarAccess.getRepetitive_statementRule() ||
				   context == grammarAccess.getStructured_statementRule()) {
					sequence_repeat_statement(context, (repeat_statement) semanticObject); 
					return; 
				}
				else break;
			case PascalPackage.SIMPLE_EXPRESSION:
				if(context == grammarAccess.getSimple_expressionRule()) {
					sequence_simple_expression(context, (simple_expression) semanticObject); 
					return; 
				}
				else break;
			case PascalPackage.STATEMENT:
				if(context == grammarAccess.getStatementRule()) {
					sequence_statement(context, (statement) semanticObject); 
					return; 
				}
				else break;
			case PascalPackage.STATEMENT_SEQUENCE:
				if(context == grammarAccess.getSTATEMENT_PARTRule() ||
				   context == grammarAccess.getCompound_statementRule() ||
				   context == grammarAccess.getStatement_sequenceRule() ||
				   context == grammarAccess.getStructured_statementRule()) {
					sequence_statement_sequence(context, (statement_sequence) semanticObject); 
					return; 
				}
				else break;
			case PascalPackage.STRUCTURED_TYPE:
				if(context == grammarAccess.getBase_typeRule() ||
				   context == grammarAccess.getElement_typeRule() ||
				   context == grammarAccess.getFile_component_typeRule() ||
				   context == grammarAccess.getFile_typeRule() ||
				   context == grammarAccess.getSet_typeRule() ||
				   context == grammarAccess.getStructured_typeRule() ||
				   context == grammarAccess.getTypeRule() ||
				   context == grammarAccess.getUnpacked_structured_typeRule()) {
					sequence_structured_type(context, (structured_type) semanticObject); 
					return; 
				}
				else break;
			case PascalPackage.SUBRANGE_TYPE:
				if(context == grammarAccess.getBase_typeRule() ||
				   context == grammarAccess.getElement_typeRule() ||
				   context == grammarAccess.getFile_component_typeRule() ||
				   context == grammarAccess.getFile_typeRule() ||
				   context == grammarAccess.getIndex_typeRule() ||
				   context == grammarAccess.getSet_typeRule() ||
				   context == grammarAccess.getSimple_typeRule() ||
				   context == grammarAccess.getSubrange_typeRule() ||
				   context == grammarAccess.getTypeRule() ||
				   context == grammarAccess.getUnpacked_structured_typeRule()) {
					sequence_subrange_type(context, (subrange_type) semanticObject); 
					return; 
				}
				else break;
			case PascalPackage.TERM:
				if(context == grammarAccess.getTermRule()) {
					sequence_term(context, (term) semanticObject); 
					return; 
				}
				else break;
			case PascalPackage.TYPE_DEFINITION:
				if(context == grammarAccess.getType_definitionRule()) {
					sequence_type_definition(context, (type_definition) semanticObject); 
					return; 
				}
				else break;
			case PascalPackage.TYPE_DEFINITION_PART:
				if(context == grammarAccess.getType_definition_partRule()) {
					sequence_type_definition_part(context, (type_definition_part) semanticObject); 
					return; 
				}
				else break;
			case PascalPackage.TYPE_IDENTIFIER:
				if(context == grammarAccess.getBase_typeRule() ||
				   context == grammarAccess.getBound_especificationRule() ||
				   context == grammarAccess.getElement_typeRule() ||
				   context == grammarAccess.getFile_component_typeRule() ||
				   context == grammarAccess.getFile_typeRule() ||
				   context == grammarAccess.getOrdinal_type_identifierRule() ||
				   context == grammarAccess.getParameter_typeRule() ||
				   context == grammarAccess.getResult_typeRule() ||
				   context == grammarAccess.getSet_typeRule() ||
				   context == grammarAccess.getTypeRule() ||
				   context == grammarAccess.getType_identifierRule() ||
				   context == grammarAccess.getUnpacked_structured_typeRule()) {
					sequence_type_identifier(context, (type_identifier) semanticObject); 
					return; 
				}
				else break;
			case PascalPackage.UNPACKED_CONFORMANT_ARRAY_SCHEMA:
				if(context == grammarAccess.getConformant_array_schemaRule() ||
				   context == grammarAccess.getParameter_typeRule() ||
				   context == grammarAccess.getUnpacked_conformant_array_schemaRule()) {
					sequence_unpacked_conformant_array_schema(context, (unpacked_conformant_array_schema) semanticObject); 
					return; 
				}
				else break;
			case PascalPackage.UPPER_BOUND:
				if(context == grammarAccess.getUpper_boundRule()) {
					sequence_upper_bound(context, (upper_bound) semanticObject); 
					return; 
				}
				else break;
			case PascalPackage.VALUE_PARAMETER_SECTION:
				if(context == grammarAccess.getFormal_parameter_sectionRule() ||
				   context == grammarAccess.getValue_parameter_sectionRule()) {
					sequence_value_parameter_section(context, (value_parameter_section) semanticObject); 
					return; 
				}
				else break;
			case PascalPackage.VARIABLE:
				if(context == grammarAccess.getFactorRule() ||
				   context == grammarAccess.getRecord_variableRule() ||
				   context == grammarAccess.getVariableRule()) {
					sequence_variable(context, (variable) semanticObject); 
					return; 
				}
				else break;
			case PascalPackage.VARIABLE_DECLARATION:
				if(context == grammarAccess.getVariable_declarationRule()) {
					sequence_variable_declaration(context, (variable_declaration) semanticObject); 
					return; 
				}
				else break;
			case PascalPackage.VARIABLE_DECLARATION_PART:
				if(context == grammarAccess.getVariable_declaration_partRule()) {
					sequence_variable_declaration_part(context, (variable_declaration_part) semanticObject); 
					return; 
				}
				else break;
			case PascalPackage.VARIABLE_IDENTIFIER:
				if(context == grammarAccess.getVariable_identifierRule()) {
					sequence_variable_identifier(context, (variable_identifier) semanticObject); 
					return; 
				}
				else break;
			case PascalPackage.VARIABLE_PARAMETER_SECTION:
				if(context == grammarAccess.getFormal_parameter_sectionRule() ||
				   context == grammarAccess.getVariable_parameter_sectionRule()) {
					sequence_variable_parameter_section(context, (variable_parameter_section) semanticObject); 
					return; 
				}
				else break;
			case PascalPackage.VARIANT:
				if(context == grammarAccess.getVariantRule()) {
					sequence_variant(context, (variant) semanticObject); 
					return; 
				}
				else break;
			case PascalPackage.VARIANT_PART:
				if(context == grammarAccess.getVariant_partRule()) {
					sequence_variant_part(context, (variant_part) semanticObject); 
					return; 
				}
				else break;
			case PascalPackage.WHILE_STATEMENT:
				if(context == grammarAccess.getRepetitive_statementRule() ||
				   context == grammarAccess.getStructured_statementRule() ||
				   context == grammarAccess.getWhile_statementRule()) {
					sequence_while_statement(context, (while_statement) semanticObject); 
					return; 
				}
				else break;
			case PascalPackage.WITH_STATEMENT:
				if(context == grammarAccess.getStructured_statementRule() ||
				   context == grammarAccess.getWith_statementRule()) {
					sequence_with_statement(context, (with_statement) semanticObject); 
					return; 
				}
				else break;
			}
		if (errorAcceptor != null) errorAcceptor.accept(diagnosticProvider.createInvalidContextOrTypeDiagnostic(semanticObject, context));
	}
	
	/**
	 * Constraint:
	 *     (sign=SIGN? value=UNSIGNED_DIGIT_SEQUENCE)
	 */
	protected void sequence_DIGIT_SEQUENCE(EObject context, DIGIT_SEQUENCE semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     programs+=program*
	 */
	protected void sequence_Model(EObject context, Model semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (
	 *         (digitSequence=DIGIT_SEQUENCE unsignedDigitSequence=UNSIGNED_DIGIT_SEQUENCE? scaleFactor=scale_factor?) | 
	 *         (digitSequence=DIGIT_SEQUENCE scaleFactor=scale_factor)
	 *     )
	 */
	protected void sequence_REAL_NUMBER(EObject context, REAL_NUMBER semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (actualParameters+=actual_parameter actualParameters+=actual_parameter*)
	 */
	protected void sequence_actual_parameter_list(EObject context, actual_parameter_list semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (indexTypes+=index_type indexTypes+=index_type* elementType=element_type)
	 */
	protected void sequence_array_type(EObject context, array_type semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (variable=variable expression=expression)
	 */
	protected void sequence_assignment_statement(EObject context, assignment_statement semanticObject) {
		if(errorAcceptor != null) {
			if(transientValues.isValueTransient(semanticObject, PascalPackage.Literals.ASSIGNMENT_STATEMENT__VARIABLE) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, PascalPackage.Literals.ASSIGNMENT_STATEMENT__VARIABLE));
			if(transientValues.isValueTransient(semanticObject, PascalPackage.Literals.ASSIGNMENT_STATEMENT__EXPRESSION) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, PascalPackage.Literals.ASSIGNMENT_STATEMENT__EXPRESSION));
		}
		INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
		SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
		feeder.accept(grammarAccess.getAssignment_statementAccess().getVariableVariableParserRuleCall_0_0(), semanticObject.getVariable());
		feeder.accept(grammarAccess.getAssignment_statementAccess().getExpressionExpressionParserRuleCall_2_0(), semanticObject.getExpression());
		feeder.finish();
	}
	
	
	/**
	 * Constraint:
	 *     (declarationPart=declaration_part statementPart=STATEMENT_PART)
	 */
	protected void sequence_block(EObject context, block semanticObject) {
		if(errorAcceptor != null) {
			if(transientValues.isValueTransient(semanticObject, PascalPackage.Literals.BLOCK__DECLARATION_PART) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, PascalPackage.Literals.BLOCK__DECLARATION_PART));
			if(transientValues.isValueTransient(semanticObject, PascalPackage.Literals.BLOCK__STATEMENT_PART) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, PascalPackage.Literals.BLOCK__STATEMENT_PART));
		}
		INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
		SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
		feeder.accept(grammarAccess.getBlockAccess().getDeclarationPartDeclaration_partParserRuleCall_0_0(), semanticObject.getDeclarationPart());
		feeder.accept(grammarAccess.getBlockAccess().getStatementPartSTATEMENT_PARTParserRuleCall_1_0(), semanticObject.getStatementPart());
		feeder.finish();
	}
	
	
	/**
	 * Constraint:
	 *     (constants+=constant constants+=constant*)
	 */
	protected void sequence_case_label_list(EObject context, case_label_list semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (caseLabelList=case_label_list statement=statement)
	 */
	protected void sequence_case_limb(EObject context, case_limb semanticObject) {
		if(errorAcceptor != null) {
			if(transientValues.isValueTransient(semanticObject, PascalPackage.Literals.CASE_LIMB__CASE_LABEL_LIST) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, PascalPackage.Literals.CASE_LIMB__CASE_LABEL_LIST));
			if(transientValues.isValueTransient(semanticObject, PascalPackage.Literals.CASE_LIMB__STATEMENT) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, PascalPackage.Literals.CASE_LIMB__STATEMENT));
		}
		INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
		SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
		feeder.accept(grammarAccess.getCase_limbAccess().getCaseLabelListCase_label_listParserRuleCall_0_0(), semanticObject.getCaseLabelList());
		feeder.accept(grammarAccess.getCase_limbAccess().getStatementStatementParserRuleCall_2_0(), semanticObject.getStatement());
		feeder.finish();
	}
	
	
	/**
	 * Constraint:
	 *     (expression=expression caseLimbs+=case_limb caseLimbs+=case_limb*)
	 */
	protected void sequence_case_statement(EObject context, case_statement semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (sign=SIGN? digitSequence=DIGIT_SEQUENCE)
	 */
	protected void sequence_constant(EObject context, ConstFromDigitSequence semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (sign=SIGN? identifier=IDENTIFIER)
	 */
	protected void sequence_constant(EObject context, ConstFromId semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (sign=SIGN? realNumber=REAL_NUMBER)
	 */
	protected void sequence_constant(EObject context, ConstFromReal semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     string=STRG
	 */
	protected void sequence_constant(EObject context, ConstFromString semanticObject) {
		if(errorAcceptor != null) {
			if(transientValues.isValueTransient(semanticObject, PascalPackage.Literals.CONST_FROM_STRING__STRING) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, PascalPackage.Literals.CONST_FROM_STRING__STRING));
		}
		INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
		SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
		feeder.accept(grammarAccess.getConstantAccess().getStringSTRGTerminalRuleCall_3_1_0(), semanticObject.getString());
		feeder.finish();
	}
	
	
	/**
	 * Constraint:
	 *     (constantName=IDENTIFIER value=constant)
	 */
	protected void sequence_constant_definition(EObject context, constant_definition semanticObject) {
		if(errorAcceptor != null) {
			if(transientValues.isValueTransient(semanticObject, PascalPackage.Literals.CONSTANT_DEFINITION__CONSTANT_NAME) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, PascalPackage.Literals.CONSTANT_DEFINITION__CONSTANT_NAME));
			if(transientValues.isValueTransient(semanticObject, PascalPackage.Literals.CONSTANT_DEFINITION__VALUE) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, PascalPackage.Literals.CONSTANT_DEFINITION__VALUE));
		}
		INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
		SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
		feeder.accept(grammarAccess.getConstant_definitionAccess().getConstantNameIDENTIFIERTerminalRuleCall_0_0(), semanticObject.getConstantName());
		feeder.accept(grammarAccess.getConstant_definitionAccess().getValueConstantParserRuleCall_2_0(), semanticObject.getValue());
		feeder.finish();
	}
	
	
	/**
	 * Constraint:
	 *     (constantDefinitions+=constant_definition constantDefinitions+=constant_definition*)
	 */
	protected void sequence_constant_definition_part(EObject context, constant_definition_part semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (
	 *         labelDeclarationPart=label_declaration_part? 
	 *         constantDeclarationPart=constant_definition_part? 
	 *         typeDeclarationPart=type_definition_part? 
	 *         variableDeclarationPart=variable_declaration_part? 
	 *         procedureAndFunctionDeclarationPart=procedure_and_function_declaration_part
	 *     )
	 */
	protected void sequence_declaration_part(EObject context, declaration_part semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (expressions+=expression expressions+=expression*)
	 */
	protected void sequence_element_list(EObject context, element_list semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (leftExpression=simple_expression (relOp=RELATIONAL_OPERATOR rightExpression=simple_expression)?)
	 */
	protected void sequence_expression(EObject context, expression semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (expressions+=expression expressions+=expression*)
	 */
	protected void sequence_expression_list(EObject context, expression_list semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (((fixedPart=fixed_part variantPart=variant_part?) | variantPart=variant_part)?)
	 */
	protected void sequence_field_list(EObject context, FieldListClass semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (recordSections+=record_section recordSections+=record_section*)
	 */
	protected void sequence_fixed_part(EObject context, fixed_part semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (variableIdentifier=variable_identifier initialExpression=initial_expression finalExpression=final_expression statement=statement)
	 */
	protected void sequence_for_statement(EObject context, for_statement semanticObject) {
		if(errorAcceptor != null) {
			if(transientValues.isValueTransient(semanticObject, PascalPackage.Literals.FOR_STATEMENT__VARIABLE_IDENTIFIER) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, PascalPackage.Literals.FOR_STATEMENT__VARIABLE_IDENTIFIER));
			if(transientValues.isValueTransient(semanticObject, PascalPackage.Literals.FOR_STATEMENT__INITIAL_EXPRESSION) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, PascalPackage.Literals.FOR_STATEMENT__INITIAL_EXPRESSION));
			if(transientValues.isValueTransient(semanticObject, PascalPackage.Literals.FOR_STATEMENT__FINAL_EXPRESSION) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, PascalPackage.Literals.FOR_STATEMENT__FINAL_EXPRESSION));
			if(transientValues.isValueTransient(semanticObject, PascalPackage.Literals.FOR_STATEMENT__STATEMENT) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, PascalPackage.Literals.FOR_STATEMENT__STATEMENT));
		}
		INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
		SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
		feeder.accept(grammarAccess.getFor_statementAccess().getVariableIdentifierVariable_identifierParserRuleCall_1_0(), semanticObject.getVariableIdentifier());
		feeder.accept(grammarAccess.getFor_statementAccess().getInitialExpressionInitial_expressionParserRuleCall_3_0(), semanticObject.getInitialExpression());
		feeder.accept(grammarAccess.getFor_statementAccess().getFinalExpressionFinal_expressionParserRuleCall_5_0(), semanticObject.getFinalExpression());
		feeder.accept(grammarAccess.getFor_statementAccess().getStatementStatementParserRuleCall_7_0(), semanticObject.getStatement());
		feeder.finish();
	}
	
	
	/**
	 * Constraint:
	 *     (parameters+=formal_parameter_section parameters+=formal_parameter_section*)
	 */
	protected void sequence_formal_parameter_list(EObject context, formal_parameter_list semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     block=block
	 */
	protected void sequence_function_body(EObject context, function_body semanticObject) {
		if(errorAcceptor != null) {
			if(transientValues.isValueTransient(semanticObject, PascalPackage.Literals.FUNCTION_BODY__BLOCK) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, PascalPackage.Literals.FUNCTION_BODY__BLOCK));
		}
		INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
		SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
		feeder.accept(grammarAccess.getFunction_bodyAccess().getBlockBlockParserRuleCall_0(), semanticObject.getBlock());
		feeder.finish();
	}
	
	
	/**
	 * Constraint:
	 *     (heading=function_heading body=function_body?)
	 */
	protected void sequence_function_declaration(EObject context, FunctionDeclarationWithHeading semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (heading=function_identification body=function_body)
	 */
	protected void sequence_function_declaration(EObject context, function_declaration semanticObject) {
		if(errorAcceptor != null) {
			if(transientValues.isValueTransient(semanticObject, PascalPackage.Literals.FUNCTION_DECLARATION__HEADING) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, PascalPackage.Literals.FUNCTION_DECLARATION__HEADING));
			if(transientValues.isValueTransient(semanticObject, PascalPackage.Literals.FUNCTION_DECLARATION__BODY) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, PascalPackage.Literals.FUNCTION_DECLARATION__BODY));
		}
		INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
		SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
		feeder.accept(grammarAccess.getFunction_declarationAccess().getHeadingFunction_identificationParserRuleCall_1_0_0(), semanticObject.getHeading());
		feeder.accept(grammarAccess.getFunction_declarationAccess().getBodyFunction_bodyParserRuleCall_1_2_0(), semanticObject.getBody());
		feeder.finish();
	}
	
	
	/**
	 * Constraint:
	 *     (functionIdentifier=function_identifier actualParameterList=actual_parameter_list)
	 */
	protected void sequence_function_designator(EObject context, function_designator semanticObject) {
		if(errorAcceptor != null) {
			if(transientValues.isValueTransient(semanticObject, PascalPackage.Literals.FUNCTION_DESIGNATOR__FUNCTION_IDENTIFIER) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, PascalPackage.Literals.FUNCTION_DESIGNATOR__FUNCTION_IDENTIFIER));
			if(transientValues.isValueTransient(semanticObject, PascalPackage.Literals.FUNCTION_DESIGNATOR__ACTUAL_PARAMETER_LIST) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, PascalPackage.Literals.FUNCTION_DESIGNATOR__ACTUAL_PARAMETER_LIST));
		}
		INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
		SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
		feeder.accept(grammarAccess.getFunction_designatorAccess().getFunctionIdentifierFunction_identifierParserRuleCall_0_0(), semanticObject.getFunctionIdentifier());
		feeder.accept(grammarAccess.getFunction_designatorAccess().getActualParameterListActual_parameter_listParserRuleCall_1_0(), semanticObject.getActualParameterList());
		feeder.finish();
	}
	
	
	/**
	 * Constraint:
	 *     (functionName=IDENTIFIER parameterList=formal_parameter_list? resultType=result_type)
	 */
	protected void sequence_function_heading(EObject context, function_heading semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     functionName=function_identifier
	 */
	protected void sequence_function_identification(EObject context, function_identification semanticObject) {
		if(errorAcceptor != null) {
			if(transientValues.isValueTransient(semanticObject, PascalPackage.Literals.FUNCTION_IDENTIFICATION__FUNCTION_NAME) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, PascalPackage.Literals.FUNCTION_IDENTIFICATION__FUNCTION_NAME));
		}
		INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
		SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
		feeder.accept(grammarAccess.getFunction_identificationAccess().getFunctionNameFunction_identifierParserRuleCall_1_0(), semanticObject.getFunctionName());
		feeder.finish();
	}
	
	
	/**
	 * Constraint:
	 *     identifier=IDENTIFIER
	 */
	protected void sequence_function_identifier(EObject context, function_identifier semanticObject) {
		if(errorAcceptor != null) {
			if(transientValues.isValueTransient(semanticObject, PascalPackage.Literals.FUNCTION_IDENTIFIER__IDENTIFIER) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, PascalPackage.Literals.FUNCTION_IDENTIFIER__IDENTIFIER));
		}
		INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
		SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
		feeder.accept(grammarAccess.getFunction_identifierAccess().getIdentifierIDENTIFIERTerminalRuleCall_0(), semanticObject.getIdentifier());
		feeder.finish();
	}
	
	
	/**
	 * Constraint:
	 *     heading=function_heading
	 */
	protected void sequence_function_parameter_section(EObject context, function_parameter_section semanticObject) {
		if(errorAcceptor != null) {
			if(transientValues.isValueTransient(semanticObject, PascalPackage.Literals.FUNCTION_PARAMETER_SECTION__HEADING) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, PascalPackage.Literals.FUNCTION_PARAMETER_SECTION__HEADING));
		}
		INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
		SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
		feeder.accept(grammarAccess.getFunction_parameter_sectionAccess().getHeadingFunction_headingParserRuleCall_0(), semanticObject.getHeading());
		feeder.finish();
	}
	
	
	/**
	 * Constraint:
	 *     label=LABEL
	 */
	protected void sequence_goto_statement(EObject context, goto_statement semanticObject) {
		if(errorAcceptor != null) {
			if(transientValues.isValueTransient(semanticObject, PascalPackage.Literals.GOTO_STATEMENT__LABEL) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, PascalPackage.Literals.GOTO_STATEMENT__LABEL));
		}
		INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
		SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
		feeder.accept(grammarAccess.getGoto_statementAccess().getLabelLABELParserRuleCall_1_0(), semanticObject.getLabel());
		feeder.finish();
	}
	
	
	/**
	 * Constraint:
	 *     (identifiers+=IDENTIFIER identifiers+=IDENTIFIER*)
	 */
	protected void sequence_identifier_list(EObject context, identifier_list semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (expression=expression statement=statement statementElse=statement?)
	 */
	protected void sequence_if_statement(EObject context, if_statement semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (labels+=LABEL labels+=LABEL*)
	 */
	protected void sequence_label_declaration_part(EObject context, label_declaration_part semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     value=constant
	 */
	protected void sequence_lower_bound(EObject context, lower_bound semanticObject) {
		if(errorAcceptor != null) {
			if(transientValues.isValueTransient(semanticObject, PascalPackage.Literals.LOWER_BOUND__VALUE) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, PascalPackage.Literals.LOWER_BOUND__VALUE));
		}
		INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
		SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
		feeder.accept(grammarAccess.getLower_boundAccess().getValueConstantParserRuleCall_0(), semanticObject.getValue());
		feeder.finish();
	}
	
	
	/**
	 * Constraint:
	 *     (boundEspecification=bound_especification typeIdentifier=type_identifier)
	 */
	protected void sequence_packed_conformant_array_schema(EObject context, packed_conformant_array_schema semanticObject) {
		if(errorAcceptor != null) {
			if(transientValues.isValueTransient(semanticObject, PascalPackage.Literals.CONFORMANT_ARRAY_SCHEMA__TYPE_IDENTIFIER) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, PascalPackage.Literals.CONFORMANT_ARRAY_SCHEMA__TYPE_IDENTIFIER));
			if(transientValues.isValueTransient(semanticObject, PascalPackage.Literals.PACKED_CONFORMANT_ARRAY_SCHEMA__BOUND_ESPECIFICATION) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, PascalPackage.Literals.PACKED_CONFORMANT_ARRAY_SCHEMA__BOUND_ESPECIFICATION));
		}
		INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
		SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
		feeder.accept(grammarAccess.getPacked_conformant_array_schemaAccess().getBoundEspecificationBound_especificationParserRuleCall_3_0(), semanticObject.getBoundEspecification());
		feeder.accept(grammarAccess.getPacked_conformant_array_schemaAccess().getTypeIdentifierType_identifierParserRuleCall_6_0(), semanticObject.getTypeIdentifier());
		feeder.finish();
	}
	
	
	/**
	 * Constraint:
	 *     pointerTypeName=type_identifier
	 */
	protected void sequence_pointer_type(EObject context, pointer_type semanticObject) {
		if(errorAcceptor != null) {
			if(transientValues.isValueTransient(semanticObject, PascalPackage.Literals.POINTER_TYPE__POINTER_TYPE_NAME) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, PascalPackage.Literals.POINTER_TYPE__POINTER_TYPE_NAME));
		}
		INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
		SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
		feeder.accept(grammarAccess.getPointer_typeAccess().getPointerTypeNameType_identifierParserRuleCall_1_0(), semanticObject.getPointerTypeName());
		feeder.finish();
	}
	
	
	/**
	 * Constraint:
	 *     ((procedures+=procedure_declaration | functions+=function_declaration)*)
	 */
	protected void sequence_procedure_and_function_declaration_part(EObject context, ProceduresAndFunctionDeclaration semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     block=block
	 */
	protected void sequence_procedure_body(EObject context, procedure_body semanticObject) {
		if(errorAcceptor != null) {
			if(transientValues.isValueTransient(semanticObject, PascalPackage.Literals.PROCEDURE_BODY__BLOCK) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, PascalPackage.Literals.PROCEDURE_BODY__BLOCK));
		}
		INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
		SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
		feeder.accept(grammarAccess.getProcedure_bodyAccess().getBlockBlockParserRuleCall_0(), semanticObject.getBlock());
		feeder.finish();
	}
	
	
	/**
	 * Constraint:
	 *     (heading=procedure_heading body=procedure_body?)
	 */
	protected void sequence_procedure_declaration(EObject context, procedure_declaration semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (procedureName=IDENTIFIER parameterList=formal_parameter_list?)
	 */
	protected void sequence_procedure_heading(EObject context, procedure_heading semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     procedureIdentifier=procedure_identifier
	 */
	protected void sequence_procedure_identification(EObject context, procedure_identification semanticObject) {
		if(errorAcceptor != null) {
			if(transientValues.isValueTransient(semanticObject, PascalPackage.Literals.PROCEDURE_IDENTIFICATION__PROCEDURE_IDENTIFIER) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, PascalPackage.Literals.PROCEDURE_IDENTIFICATION__PROCEDURE_IDENTIFIER));
		}
		INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
		SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
		feeder.accept(grammarAccess.getProcedure_identificationAccess().getProcedureIdentifierProcedure_identifierParserRuleCall_1_0(), semanticObject.getProcedureIdentifier());
		feeder.finish();
	}
	
	
	/**
	 * Constraint:
	 *     identifier=IDENTIFIER
	 */
	protected void sequence_procedure_identifier(EObject context, procedure_identifier semanticObject) {
		if(errorAcceptor != null) {
			if(transientValues.isValueTransient(semanticObject, PascalPackage.Literals.PROCEDURE_IDENTIFIER__IDENTIFIER) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, PascalPackage.Literals.PROCEDURE_IDENTIFIER__IDENTIFIER));
		}
		INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
		SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
		feeder.accept(grammarAccess.getProcedure_identifierAccess().getIdentifierIDENTIFIERTerminalRuleCall_0(), semanticObject.getIdentifier());
		feeder.finish();
	}
	
	
	/**
	 * Constraint:
	 *     heading=procedure_heading
	 */
	protected void sequence_procedure_parameter_section(EObject context, procedure_parameter_section semanticObject) {
		if(errorAcceptor != null) {
			if(transientValues.isValueTransient(semanticObject, PascalPackage.Literals.PROCEDURE_PARAMETER_SECTION__HEADING) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, PascalPackage.Literals.PROCEDURE_PARAMETER_SECTION__HEADING));
		}
		INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
		SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
		feeder.accept(grammarAccess.getProcedure_parameter_sectionAccess().getHeadingProcedure_headingParserRuleCall_0(), semanticObject.getHeading());
		feeder.finish();
	}
	
	
	/**
	 * Constraint:
	 *     (procedureIdentifier=procedure_identifier actualParameterList=actual_parameter_list?)
	 */
	protected void sequence_procedure_statement(EObject context, procedure_statement semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (programName=IDENTIFIER params=identifier_list)
	 */
	protected void sequence_program_heading(EObject context, program_heading semanticObject) {
		if(errorAcceptor != null) {
			if(transientValues.isValueTransient(semanticObject, PascalPackage.Literals.PROGRAM_HEADING__PROGRAM_NAME) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, PascalPackage.Literals.PROGRAM_HEADING__PROGRAM_NAME));
			if(transientValues.isValueTransient(semanticObject, PascalPackage.Literals.PROGRAM_HEADING__PARAMS) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, PascalPackage.Literals.PROGRAM_HEADING__PARAMS));
		}
		INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
		SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
		feeder.accept(grammarAccess.getProgram_headingAccess().getProgramNameIDENTIFIERTerminalRuleCall_1_0(), semanticObject.getProgramName());
		feeder.accept(grammarAccess.getProgram_headingAccess().getParamsIdentifier_listParserRuleCall_3_0(), semanticObject.getParams());
		feeder.finish();
	}
	
	
	/**
	 * Constraint:
	 *     (heading=program_heading block=block)
	 */
	protected void sequence_program(EObject context, program semanticObject) {
		if(errorAcceptor != null) {
			if(transientValues.isValueTransient(semanticObject, PascalPackage.Literals.PROGRAM__HEADING) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, PascalPackage.Literals.PROGRAM__HEADING));
			if(transientValues.isValueTransient(semanticObject, PascalPackage.Literals.PROGRAM__BLOCK) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, PascalPackage.Literals.PROGRAM__BLOCK));
		}
		INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
		SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
		feeder.accept(grammarAccess.getProgramAccess().getHeadingProgram_headingParserRuleCall_0_0(), semanticObject.getHeading());
		feeder.accept(grammarAccess.getProgramAccess().getBlockBlockParserRuleCall_1_0(), semanticObject.getBlock());
		feeder.finish();
	}
	
	
	/**
	 * Constraint:
	 *     (identifierlist=identifier_list type=type)
	 */
	protected void sequence_record_section(EObject context, record_section semanticObject) {
		if(errorAcceptor != null) {
			if(transientValues.isValueTransient(semanticObject, PascalPackage.Literals.RECORD_SECTION__IDENTIFIERLIST) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, PascalPackage.Literals.RECORD_SECTION__IDENTIFIERLIST));
			if(transientValues.isValueTransient(semanticObject, PascalPackage.Literals.RECORD_SECTION__TYPE) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, PascalPackage.Literals.RECORD_SECTION__TYPE));
		}
		INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
		SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
		feeder.accept(grammarAccess.getRecord_sectionAccess().getIdentifierlistIdentifier_listParserRuleCall_0_0(), semanticObject.getIdentifierlist());
		feeder.accept(grammarAccess.getRecord_sectionAccess().getTypeTypeParserRuleCall_2_0(), semanticObject.getType());
		feeder.finish();
	}
	
	
	/**
	 * Constraint:
	 *     (StatementSequence=statement_sequence expression=expression)
	 */
	protected void sequence_repeat_statement(EObject context, repeat_statement semanticObject) {
		if(errorAcceptor != null) {
			if(transientValues.isValueTransient(semanticObject, PascalPackage.Literals.REPEAT_STATEMENT__STATEMENT_SEQUENCE) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, PascalPackage.Literals.REPEAT_STATEMENT__STATEMENT_SEQUENCE));
			if(transientValues.isValueTransient(semanticObject, PascalPackage.Literals.REPEAT_STATEMENT__EXPRESSION) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, PascalPackage.Literals.REPEAT_STATEMENT__EXPRESSION));
		}
		INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
		SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
		feeder.accept(grammarAccess.getRepeat_statementAccess().getStatementSequenceStatement_sequenceParserRuleCall_1_0(), semanticObject.getStatementSequence());
		feeder.accept(grammarAccess.getRepeat_statementAccess().getExpressionExpressionParserRuleCall_3_0(), semanticObject.getExpression());
		feeder.finish();
	}
	
	
	/**
	 * Constraint:
	 *     (sign=SIGN? leftTerm=term ((addOps+=ADITION_OPERATOR | addOps+=SIGN) rightTerms+=term)*)
	 */
	protected void sequence_simple_expression(EObject context, simple_expression semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (statements+=statement statements+=statement*)
	 */
	protected void sequence_statement_sequence(EObject context, statement_sequence semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (label=LABEL? (simpleStatement=simple_statement | structuredStatement=structured_statement))
	 */
	protected void sequence_statement(EObject context, statement semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     unpackedStructuredType=unpacked_structured_type
	 */
	protected void sequence_structured_type(EObject context, structured_type semanticObject) {
		if(errorAcceptor != null) {
			if(transientValues.isValueTransient(semanticObject, PascalPackage.Literals.STRUCTURED_TYPE__UNPACKED_STRUCTURED_TYPE) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, PascalPackage.Literals.STRUCTURED_TYPE__UNPACKED_STRUCTURED_TYPE));
		}
		INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
		SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
		feeder.accept(grammarAccess.getStructured_typeAccess().getUnpackedStructuredTypeUnpacked_structured_typeParserRuleCall_1_0(), semanticObject.getUnpackedStructuredType());
		feeder.finish();
	}
	
	
	/**
	 * Constraint:
	 *     (lowerBound=lower_bound upperBound=upper_bound)
	 */
	protected void sequence_subrange_type(EObject context, subrange_type semanticObject) {
		if(errorAcceptor != null) {
			if(transientValues.isValueTransient(semanticObject, PascalPackage.Literals.SUBRANGE_TYPE__LOWER_BOUND) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, PascalPackage.Literals.SUBRANGE_TYPE__LOWER_BOUND));
			if(transientValues.isValueTransient(semanticObject, PascalPackage.Literals.SUBRANGE_TYPE__UPPER_BOUND) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, PascalPackage.Literals.SUBRANGE_TYPE__UPPER_BOUND));
		}
		INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
		SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
		feeder.accept(grammarAccess.getSubrange_typeAccess().getLowerBoundLower_boundParserRuleCall_0_0(), semanticObject.getLowerBound());
		feeder.accept(grammarAccess.getSubrange_typeAccess().getUpperBoundUpper_boundParserRuleCall_2_0(), semanticObject.getUpperBound());
		feeder.finish();
	}
	
	
	/**
	 * Constraint:
	 *     (leftFactor=factor (multops+=MULTIPLICATION_OPERATOR rightFactors+=factor)*)
	 */
	protected void sequence_term(EObject context, term semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (typeDefinitions+=type_definition typeDefinitions+=type_definition*)
	 */
	protected void sequence_type_definition_part(EObject context, type_definition_part semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (typeName=IDENTIFIER type=type)
	 */
	protected void sequence_type_definition(EObject context, type_definition semanticObject) {
		if(errorAcceptor != null) {
			if(transientValues.isValueTransient(semanticObject, PascalPackage.Literals.TYPE_DEFINITION__TYPE_NAME) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, PascalPackage.Literals.TYPE_DEFINITION__TYPE_NAME));
			if(transientValues.isValueTransient(semanticObject, PascalPackage.Literals.TYPE_DEFINITION__TYPE) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, PascalPackage.Literals.TYPE_DEFINITION__TYPE));
		}
		INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
		SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
		feeder.accept(grammarAccess.getType_definitionAccess().getTypeNameIDENTIFIERTerminalRuleCall_0_0(), semanticObject.getTypeName());
		feeder.accept(grammarAccess.getType_definitionAccess().getTypeTypeParserRuleCall_2_0(), semanticObject.getType());
		feeder.finish();
	}
	
	
	/**
	 * Constraint:
	 *     typeIdentifierName=IDENTIFIER
	 */
	protected void sequence_type_identifier(EObject context, type_identifier semanticObject) {
		if(errorAcceptor != null) {
			if(transientValues.isValueTransient(semanticObject, PascalPackage.Literals.TYPE_IDENTIFIER__TYPE_IDENTIFIER_NAME) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, PascalPackage.Literals.TYPE_IDENTIFIER__TYPE_IDENTIFIER_NAME));
		}
		INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
		SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
		feeder.accept(grammarAccess.getType_identifierAccess().getTypeIdentifierNameIDENTIFIERTerminalRuleCall_0(), semanticObject.getTypeIdentifierName());
		feeder.finish();
	}
	
	
	/**
	 * Constraint:
	 *     (
	 *         boundEspecifications+=bound_especification 
	 *         boundEspecifications+=bound_especification* 
	 *         (typeIdentifier=type_identifier | conformantArraySchema=conformant_array_schema)
	 *     )
	 */
	protected void sequence_unpacked_conformant_array_schema(EObject context, unpacked_conformant_array_schema semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     value=constant
	 */
	protected void sequence_upper_bound(EObject context, upper_bound semanticObject) {
		if(errorAcceptor != null) {
			if(transientValues.isValueTransient(semanticObject, PascalPackage.Literals.UPPER_BOUND__VALUE) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, PascalPackage.Literals.UPPER_BOUND__VALUE));
		}
		INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
		SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
		feeder.accept(grammarAccess.getUpper_boundAccess().getValueConstantParserRuleCall_0(), semanticObject.getValue());
		feeder.finish();
	}
	
	
	/**
	 * Constraint:
	 *     (identifierList=identifier_list type=parameter_type)
	 */
	protected void sequence_value_parameter_section(EObject context, value_parameter_section semanticObject) {
		if(errorAcceptor != null) {
			if(transientValues.isValueTransient(semanticObject, PascalPackage.Literals.VALUE_PARAMETER_SECTION__IDENTIFIER_LIST) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, PascalPackage.Literals.VALUE_PARAMETER_SECTION__IDENTIFIER_LIST));
			if(transientValues.isValueTransient(semanticObject, PascalPackage.Literals.VALUE_PARAMETER_SECTION__TYPE) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, PascalPackage.Literals.VALUE_PARAMETER_SECTION__TYPE));
		}
		INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
		SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
		feeder.accept(grammarAccess.getValue_parameter_sectionAccess().getIdentifierListIdentifier_listParserRuleCall_0_0(), semanticObject.getIdentifierList());
		feeder.accept(grammarAccess.getValue_parameter_sectionAccess().getTypeParameter_typeParserRuleCall_2_0(), semanticObject.getType());
		feeder.finish();
	}
	
	
	/**
	 * Constraint:
	 *     (variables+=variable_declaration variables+=variable_declaration*)
	 */
	protected void sequence_variable_declaration_part(EObject context, variable_declaration_part semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (variableNames=identifier_list type=type)
	 */
	protected void sequence_variable_declaration(EObject context, variable_declaration semanticObject) {
		if(errorAcceptor != null) {
			if(transientValues.isValueTransient(semanticObject, PascalPackage.Literals.VARIABLE_DECLARATION__VARIABLE_NAMES) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, PascalPackage.Literals.VARIABLE_DECLARATION__VARIABLE_NAMES));
			if(transientValues.isValueTransient(semanticObject, PascalPackage.Literals.VARIABLE_DECLARATION__TYPE) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, PascalPackage.Literals.VARIABLE_DECLARATION__TYPE));
		}
		INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
		SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
		feeder.accept(grammarAccess.getVariable_declarationAccess().getVariableNamesIdentifier_listParserRuleCall_0_0(), semanticObject.getVariableNames());
		feeder.accept(grammarAccess.getVariable_declarationAccess().getTypeTypeParserRuleCall_2_0(), semanticObject.getType());
		feeder.finish();
	}
	
	
	/**
	 * Constraint:
	 *     identifier=IDENTIFIER
	 */
	protected void sequence_variable_identifier(EObject context, variable_identifier semanticObject) {
		if(errorAcceptor != null) {
			if(transientValues.isValueTransient(semanticObject, PascalPackage.Literals.VARIABLE_IDENTIFIER__IDENTIFIER) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, PascalPackage.Literals.VARIABLE_IDENTIFIER__IDENTIFIER));
		}
		INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
		SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
		feeder.accept(grammarAccess.getVariable_identifierAccess().getIdentifierIDENTIFIERTerminalRuleCall_0(), semanticObject.getIdentifier());
		feeder.finish();
	}
	
	
	/**
	 * Constraint:
	 *     (((expressionList=expression_list variableL=variable_l) | (identifier=IDENTIFIER variableL=variable_l) | variableL=variable_l)?)
	 */
	protected void sequence_variable_l(EObject context, VariableLClass semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (identifierList=identifier_list type=parameter_type)
	 */
	protected void sequence_variable_parameter_section(EObject context, variable_parameter_section semanticObject) {
		if(errorAcceptor != null) {
			if(transientValues.isValueTransient(semanticObject, PascalPackage.Literals.VARIABLE_PARAMETER_SECTION__IDENTIFIER_LIST) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, PascalPackage.Literals.VARIABLE_PARAMETER_SECTION__IDENTIFIER_LIST));
			if(transientValues.isValueTransient(semanticObject, PascalPackage.Literals.VARIABLE_PARAMETER_SECTION__TYPE) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, PascalPackage.Literals.VARIABLE_PARAMETER_SECTION__TYPE));
		}
		INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
		SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
		feeder.accept(grammarAccess.getVariable_parameter_sectionAccess().getIdentifierListIdentifier_listParserRuleCall_1_0(), semanticObject.getIdentifierList());
		feeder.accept(grammarAccess.getVariable_parameter_sectionAccess().getTypeParameter_typeParserRuleCall_3_0(), semanticObject.getType());
		feeder.finish();
	}
	
	
	/**
	 * Constraint:
	 *     (name=IDENTIFIER variableL=variable_l)
	 */
	protected void sequence_variable(EObject context, variable semanticObject) {
		if(errorAcceptor != null) {
			if(transientValues.isValueTransient(semanticObject, PascalPackage.Literals.VARIABLE__NAME) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, PascalPackage.Literals.VARIABLE__NAME));
			if(transientValues.isValueTransient(semanticObject, PascalPackage.Literals.VARIABLE__VARIABLE_L) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, PascalPackage.Literals.VARIABLE__VARIABLE_L));
		}
		INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
		SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
		feeder.accept(grammarAccess.getVariableAccess().getNameIDENTIFIERTerminalRuleCall_0_0(), semanticObject.getName());
		feeder.accept(grammarAccess.getVariableAccess().getVariableLVariable_lParserRuleCall_1_0(), semanticObject.getVariableL());
		feeder.finish();
	}
	
	
	/**
	 * Constraint:
	 *     (variants+=variant variants+=variant*)
	 */
	protected void sequence_variant_part(EObject context, variant_part semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (caseLabelList=case_label_list fieldList=field_list)
	 */
	protected void sequence_variant(EObject context, variant semanticObject) {
		if(errorAcceptor != null) {
			if(transientValues.isValueTransient(semanticObject, PascalPackage.Literals.VARIANT__CASE_LABEL_LIST) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, PascalPackage.Literals.VARIANT__CASE_LABEL_LIST));
			if(transientValues.isValueTransient(semanticObject, PascalPackage.Literals.VARIANT__FIELD_LIST) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, PascalPackage.Literals.VARIANT__FIELD_LIST));
		}
		INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
		SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
		feeder.accept(grammarAccess.getVariantAccess().getCaseLabelListCase_label_listParserRuleCall_0_0(), semanticObject.getCaseLabelList());
		feeder.accept(grammarAccess.getVariantAccess().getFieldListField_listParserRuleCall_3_0(), semanticObject.getFieldList());
		feeder.finish();
	}
	
	
	/**
	 * Constraint:
	 *     (expression=expression statement=statement)
	 */
	protected void sequence_while_statement(EObject context, while_statement semanticObject) {
		if(errorAcceptor != null) {
			if(transientValues.isValueTransient(semanticObject, PascalPackage.Literals.WHILE_STATEMENT__EXPRESSION) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, PascalPackage.Literals.WHILE_STATEMENT__EXPRESSION));
			if(transientValues.isValueTransient(semanticObject, PascalPackage.Literals.WHILE_STATEMENT__STATEMENT) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, PascalPackage.Literals.WHILE_STATEMENT__STATEMENT));
		}
		INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
		SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
		feeder.accept(grammarAccess.getWhile_statementAccess().getExpressionExpressionParserRuleCall_1_0(), semanticObject.getExpression());
		feeder.accept(grammarAccess.getWhile_statementAccess().getStatementStatementParserRuleCall_3_0(), semanticObject.getStatement());
		feeder.finish();
	}
	
	
	/**
	 * Constraint:
	 *     (recordVariables+=record_variable recordVariables+=record_variable* statement=statement)
	 */
	protected void sequence_with_statement(EObject context, with_statement semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
}
